\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage[frenchb]{babel} 
\usepackage{geometry}
\geometry{hmargin=3cm,vmargin=3.5cm}

\title{Reflexion sur les classes et leur optimisation}
\date{\today}
\begin{document}

\maketitle

Pour chaque classe, nous implémenterons les accesseurs nécessaires ainsi qu'une méthode show() qui affichera les caractéristiques d'un objet de la classe (à la manière d'un toString()) pour nous aider lors du développement.

\section{Variable}

Comme dit précédement, la mise en page d'un contenu web se fait par l'intermédiaire de feuilles de style. Elles peuvent être vues comme des objets qui possèdent plusieurs variables, et chacune de ces variables prenant ses valeurs dans son propre domaine. Les objets de la classe Variable vont donc porter sur les différentes parties que l'on peut modifier dans un site web. \\
\textit{Exemple}\\
Variables possibles : taille du texte, couleur du texte.\\
Domaine(tailleTexte) : ( moyenne, grande )\\
Domaine(couleurTexte) : ( noir, bleu, vert )\\
couleurTexte est le nom de la variable, noir bleu et vert sont les valeurs qu'elle peut prendre.\\
\\
La classe Variable va donc posséder deux attributs : \\
 - son identifiant, le nom de la variable\\
 - son domaine, représenté par une collection de valeurs possibles\\
En plus des accesseurs, il faudra pouvoir :\\
 - comparer deux objets Variables\\
 - récupérer le nombre de valeurs de son domaine\\
 - vérifier si une valeur fait partie du domaine\\
 - ajouter / enlever une valeur du domaine\\

\section{Outcome}
Une outcome est une instanciation de l'ensemble des variables. On l'appelle aussi solution.\\
Elle va donc contenir autant de champs qu'il y a de variables.\\
\textit{Exemple}\\
Soient les variables de l'exemple précédent : taille du texte, couleur du texte.\\
Domaine(tailleTexte) : \{ moyenne, grande \}\\
Domaine(couleurTexte) : \{ noir, bleu, vert \}\\
\{moyenne - bleu\}, \{moyenne - verte\} et \{grande - bleu\} sont trois outcomes possibles sur les variables tailleTexte et couleurTexte.\\
\\
La classe Outcome va donc contenir : \\
 - Une collection de valeurs de ces Variables, représentant l'instanciation\\
Les méthodes sur un objet de la classe Outcome vont devoir :\\
 - comparer deux outcomes\\
 - cloner une outcome\\
 - récupérer le nombre de champs de l'outcome\\
 - générer de nouvelles outcomes à partir d'une outcome initiale à laquelle on associe une nouvelle Variable\\


\section{Omega}

Oméga est la notation de l'espace d’alternative combinatoire.\\
Il est fondé sur notre ensemble de variables. L'ensemble des variables ainsi que leurs domaines étant finis, l'ensemble des outcomes possibles est lui aussi fini.\\
On peut donc définir cet ensemble de deux manières différentes :\\
\begin{itemize}
\item En extension : c'est-à-dire écrire explicitement toutes les outcomes possibles.\\
Avantages : Lors des calculs, il est plus facile de manipuler l'ensemble des outcomes (vérifier si une outcome est présente dans l'ensemble, les supprimer etc ...).\\
Inconvénients : On assiste rapidement à une explosion combinatoire : six variables possédant chacune six valeurs dans leur domaine donnent 46 656 instanciations possibles. Cela prendra rapidement beaucoup de mémoire.\\
\item En intention : on n'écrit pas explicitement toutes les outcomes.  On définit cet ensemble implicitement en donnant la liste des variables sur lequel il est fondé.\\
Avantages : On ne prend pas beaucoup de mémoire.\\
Inconvénients  : Il est parfois difficile de manipuler l'ensemble de ces outcomes.\\
\end{itemize}

On peut cependant facilement prévoir le nombre d'outcomes que va comporter un ensemble omega :\\
Soient \{V1, ..., Vn\} l'ensemble des variables et \{D1, ..., Dn\} leur domaine respectif.\\
P(|Di|) i appartenant [1 .. n] est le nombre d'outcomes possibles fondées sur l'ensemble {V1, ..., Vn}\\

\textit{Exemple} : Soient deux variables qui prennent les valeurs dans leur domaine de chacun deux éléments.\\
Domaine(texteTaille) = \{ 12px, 18px \}\\
Domaine(contraste) = \{ faible, fort \}\\
L’ensemble des instanciations possibles seraient donc :\\
Oméga = \{ \{12px, faible\} , \{12px, fort\} , \{18px, faible\} , \{18px,fort\} \}\\
|Oméga| = |Domaine(texteTaille)| * |Domaine(contraste)| = 2*2 = 4\\
\\
Un objet Oméga possèdera alors les attributs suivants : \\
 - Une collection de Variables sur lesquelles il est fondé\\
 - Une collections qui possède l'ensemble des Outcomes possibles, que nous choisirons de générer ou non\\
Les méthodes dont nous aurons besoins seront les suivantes : \\
 - générer la collection d'Outcomes\\
 - récupérer le nombre d'outcomes possibles maximum (prevoir un long int ?)\\
 - récupérer le nombre d'outcomes\\
 - récuperer la ième outcome\\
 - supprimer la iéme outcome\\

\subsection{Optimisation}
L'ensembles des solutions possibles ne sera généré que l'orsque l'on en aura besoins, c'est-à-dire avant l'execution des algorithmes, juste avant la définition des contraintes. \\
Il faudra faire attention à la complexité de l'algorithme de génération de cet ensemble à partir des variables.\\
Plus tard, nous risquons de faire des modifications sur les valeurs des variables qui vont générer Oméga (enlever des valeurs ou même des variables en fonction des préférences) afin de réduire le nombre d'Outcomes. Pour ne pas modifier les variables definies au départ, il faudra faire une copie des objets Variable dans Oméga et donc ne pas conserver de pointeurs vers ces objets.

\section{Preference}

\subsection{Les préférences en général}
Une relation de préférence est une relation établie entre les valeurs des variables (que ce soit au sein de la même variable ou de deux variables différente), et qui définie quelles sont les valeurs qui vont être préférés à quelles autres valeurs.\\

\textit{Exemple} : Soit l'exemple précédent : \\
Domaine(texteTaille) = \{ 12px, 18px \}\\
Domaine(contraste) = \{ faible, fort \}\\
"Je préfère que le texte soit de taille 18px plutot que 12px" : 18px > 12px\\
"J'accorde plus d'importance à un texte de grande taille qu'à un contraste fort" : 18px > fort\\
\\
La classe Preference possèdera alors deux attributs :\\
 - la valeur la plus préférée\\
 - la valeur la moins préférée\\
Les méthodes à implémenter seront : \\
 - récupérer la valeur la plus préférée\\
 - récupérer la valeur la moins préférée\\

\subsection{Les préférences conditionnelles}
Nous avons vu précédement que les préférences peuvent être de deux formes : nous vennons de voir les générales qui ne dépendent pas d'un contexte particulier, et nous allons maintenant nous pencher sur les préférences conditionnelles, qui elles dépendent d'un contexte, d'une condition.\\
Ce type de préférence est sensiblement le même que celui vu précédement, ormis le fait qu'elle va contenir une condition. Nous allons donc créer une classe PreferenceConditional qui va héritée de la classe Preference.\\
\\
La classe PreferenceConditional aura en plus comme attribut : \\
 - une condition, qui sera respectée ou non selon le contexte\\
Les méthodes à rajouter seront : \\
 - récupérer la condition (1)\\
 - savoir si la condition est remplie ou non\\
\\
(1) A ce stade de la conception, nous ne savons pas encore sous quelle forme se présentera la condition : elle pourrait prendre la forme d'une valeur d'une de nos variables, ou alors d'une chaine de caractère représentative du contexte. \\
Si on veut que la taille du texte dépende du contraste : si fort, alors 15px > 18px\\
Si une préférence conditionnelle dépend de la présence d'un menu dans la page, on a alors condition implicite : je préfère une police en gras pour les liens du menu (bold > normal), s'il y a un menu.\\
On n'exprime pas la condition à travers une valeur, la préférence se comporte comme une préférence générale, on la prend en compte seulement si la condition (ici la présence d'un menu) est remplie.

\section{Preference Set}
Pour nos algortihmes, nous avons besoins de manipuler un certain nombre de préférences. Afin de faciliter cette étape, nous avons décidé de faire une classe qui regrouperait une collection d'objets Preference.\\
\\
La classe PreferenceSet contiendrait alors : \\
 - une collection d'objets Preference\\
 - une sémantique (ou une liste ordonnée des différentes sémantiques ?) parmis : Strong, CeterisParibus, Pessimist, Optimist.\\
Les méthodes serviraient à : \\
 - ajouter une préférence\\
 - supprimer une préférence\\
 - récupérer une ou toute les préférences\\
 - récupérer la sémantique\\

\subsection{Optimisation}
Les opérations sur les préférences de cette classes ne change pas la valeur des objets Preference : on peut donc garder des pointeurs vers ces objets, ce qui prendra moins de place.

\section{Constraint}
La dernière classe dont nous avons besoins est necessaire pour le déroulement de l'algorithme. Une contrainte est générée à partir d'un ensemble Oméga est d'une préférence. Elle contient deux ensembles d'Outcomes. \\
\\
Les attributs de la classe Constraint sont donc : \\
 - une première collection d'Outcomes, partie droite\\
 - une seconde collection d'Outcomes, partie gauche\\
Les méthodes pourront : \\
 - récupérer la partie droite ou gauche\\
 - tester si une outcome est dans la partie droite ou gauche\\


\subsection{Optimisation}
Lorsque l'on passe Oméga dans le constructeur, l'ensemble des Outcomes doit être généré. On ne doit alors ni le modifier, ni le copier (passage par valeur avec le mot clé const) pour éviter la copie de beaucoup de valeurs.\\
Les collections d'objets Outcome seront des pointeurs sur les Outcomes de Oméga : nous n'auront pas besoins de modifier ces objets, et un pointeur prendra moins de place qu'un objet de la classe.

\section{Conteneurs de séquence}
Nous avons besoins d'utiliser des collections d'objets. Certaines seront certainement très importantes (Omega), nous avons donc besoins de les traiter le mieux possible.\\
Nous avons penser a utiliser des tableaux de pointeurs, mais certaines opérations semblent plutot couteuse (en temps et en mémoire).\\
Nous avons donc cherché du côté de la bibliothèque STL (puisque nous utiliserons C++) qui propose trois conteneurs de séquence : \\
\begin{itemize}
\item La liste : elle permet les insertions/suppressions rapides n'importe ou dans le conteneur, mais on ne peut pas acceder directement à un élément. Elle prend un peu plus de place qu'un vecteur.\\
\item Le vecteur : il se comporte comme un tableau. Les insertions/suppression internes sont linéaires à la taille du tableau.\\
\item Le deque : il permet d'acceder rapidement à un élément et les insertions/suppressions rapides au début et à la fin du conteneur. L'insertion au milieu est linéaire.\\
\end{itemize}
Voyons voir les traitements que nous allons devoir faire sur Omega : \\
 - Générer l'ensemble des solutions possibles : ajout d'Outcome à la fin (ou au debut)\\
 - Générer les deux parties des différentes contraintes : parcourir tous les éléments\\
 - Supprimer les éléments de Omega durant les algorithmes : suppression en milieu de conteneurs\\
Il semblerait donc que nous n'ayons pas besoins d'accéder à un élément précis, et que la suppression en milieu de conteneur se fera très fréquement. \\
List semble le plus approprié pour un objet Omega.\\
Les autres conteneurs étant très petits comparés à celui-ci, et l'accès direct à un de ces éléments étant nécessaire, le vector sera préférable.


\end{document}
